home *** CD-ROM | disk | FTP | other *** search
/ CD Exchange / CD Exchange - Volume 1.iso / education / gravity-well / gw-main.c < prev    next >
C/C++ Source or Header  |  1989-09-24  |  5KB  |  144 lines
  1. /*
  2.       GW-Main.c
  3.       Root module for Gravity-Well
  4.       Gary Teachout
  5.       Copyright   July 1989
  6.       lc -cs GW-Main    To compile with Lattice 5.0
  7. */
  8.  
  9.  
  10.  #include "GW-Include.h"
  11.  
  12.  
  13.  void main()
  14.  {
  15.    startup()  ;
  16.    for ( ; ; )
  17.    {
  18.       takestep( g.timestep )  ;
  19.       g.elapsedtime += g.timestep  ;
  20.       updatedisplay()  ;
  21.       interface()  ;
  22.    }
  23.  }
  24.  
  25.  
  26.  void takestep( time )
  27.    double   time  ;
  28.  {
  29.    struct dv   av , rv , tv , uv  ;
  30.    double      r , v  ;
  31.    long        i , j , flag , s , sn = 1 ;
  32.    
  33.  
  34.    for ( i = 0 ; i < 20 ; i ++ )
  35.       g.objects[ i ].oldpos = g.objects[ i ].position  ;
  36.  
  37.    for ( flag = 1 ; flag ; )
  38.    {
  39.       for ( flag = i = 0 ; ( i < 20 ) && ( ! flag ) ; i ++ )
  40.       {
  41.          if ( g.objects[ i ].flags && ( ! g.objects[ i ].collision ) )
  42.          {
  43.             for ( j = 0 ; ( j < 20 ) && ( ! flag ) ; j ++ )
  44.             {
  45.                if (     ( g.objects[ j ].flags )
  46.                      && ( ! g.objects[ j ].collision )
  47.                      && ( g.objects[ j ].mass )
  48.                      && ( i != j )  )
  49.                {
  50.                   subdv(   &g.objects[ j ].velocity ,
  51.                            &g.objects[ i ].velocity ,
  52.                            &rv  )  ;
  53.                   magdv( &rv , &v )  ;
  54.                   subdv(   &g.objects[ j ].position ,
  55.                            &g.objects[ i ].position ,
  56.                            &rv  )  ;
  57.                   magdv( &rv , &r )  ;
  58.                   if ( ( r < ( v * time * g.magic ) ) && ( sn < 256 ) )
  59.                   {
  60.                      flag = 1  ;
  61.                      time = time * 0.5  ;
  62.                      sn = sn * 2  ;
  63.                   }
  64.                }
  65.             }
  66.          }
  67.       }
  68.    }
  69.    for ( s = 0 ; s < sn ; s ++ )
  70.    {
  71.       for ( i = 0 ; i < 20 ; i ++ )
  72.       {
  73.          if ( g.objects[ i ].flags && ( ! g.objects[ i ].collision ) )
  74.          {
  75.             av = zerodv  ;
  76.             for ( j = 0 ; j < 20 ; j ++ )
  77.             {
  78.                if (     ( g.objects[ j ].flags )
  79.                      && ( ! g.objects[ j ].collision )
  80.                      && ( g.objects[ j ].mass )
  81.                      && ( i != j )  )
  82.                {
  83.                   subdv(   &g.objects[ j ].position ,
  84.                            &g.objects[ i ].position , 
  85.                            &rv  )  ;
  86.                   magdv( &rv , &r )  ;
  87.                   if ( r < (     g.objects[ i ].radius
  88.                               +  g.objects[ j ].radius ) )
  89.                   {
  90.                      endtrail( i , j )  ;
  91.                      g.objects[ i ].collision = 1  ;
  92.                      v =      g.objects[ i ].mass 
  93.                            /  (     g.objects[ i ].mass
  94.                                  +  g.objects[ j ].mass )  ;
  95.                      scaledv( &rv , &v , &tv )  ;
  96.                      subdv(   &g.objects[ j ].position ,
  97.                               &tv ,
  98.                               &g.objects[ j ].position )  ;
  99.                      g.objects[ j ].oldpos = g.objects[ j ].position  ;
  100.                      scaledv(    &g.objects[ i ].velocity ,
  101.                                  &g.objects[ i ].mass ,
  102.                                  &tv )  ;
  103.                      scaledv(    &g.objects[ j ].velocity ,
  104.                                  &g.objects[ j ].mass ,
  105.                                  &uv )  ;
  106.                      adddv( &tv , &uv , &g.objects[ j ].velocity )  ;
  107.                      g.objects[ j ].mass += g.objects[ i ].mass  ;
  108.                      v = 1 / g.objects[ j ].mass  ;
  109.                      scaledv(    &g.objects[ j ].velocity ,
  110.                                  &v ,
  111.                                  &g.objects[ j ].velocity )  ;
  112.                      j = 30  ;
  113.                   }
  114.                   else
  115.                   {
  116.                      r = ( g.objects[ j ].mass * time ) / ( r * r * r )  ;
  117.                      scaledv( &rv , &r , &tv )  ;
  118.                      adddv( &av , &tv , &av )  ;
  119.                   }
  120.                }
  121.             }
  122.             adddv(   &g.objects[ i ].velocity ,
  123.                      &av ,
  124.                      &g.objects[ i ].velocity )  ;
  125.          }
  126.       }
  127.       for ( i = 0 ; i < 20 ; i ++ )
  128.       {
  129.          if ( g.objects[ i ].flags && ( ! g.objects[ i ].collision ) )
  130.          {
  131.             scaledv( &g.objects[ i ].velocity ,
  132.                      &time ,
  133.                      &tv )  ;
  134.             adddv(   &g.objects[ i ].position ,
  135.                      &tv ,
  136.                      &g.objects[ i ].position )  ;
  137.          }
  138.       }
  139.    }
  140.  }
  141.  
  142.  
  143.  
  144.